home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 127 / PC Guia 127.iso / Software / Produtividade / OpenOffice.org 2.0.1 / openofficeorg3.cab / getopt.py < prev    next >
Text File  |  2005-11-19  |  7KB  |  212 lines
  1. # -*- coding: iso-8859-1 -*-
  2. """Parser for command line options.
  3.  
  4. This module helps scripts to parse the command line arguments in
  5. sys.argv.  It supports the same conventions as the Unix getopt()
  6. function (including the special meanings of arguments of the form `-'
  7. and `--').  Long options similar to those supported by GNU software
  8. may be used as well via an optional third argument.  This module
  9. provides two functions and an exception:
  10.  
  11. getopt() -- Parse command line options
  12. gnu_getopt() -- Like getopt(), but allow option and non-option arguments
  13. to be intermixed.
  14. GetoptError -- exception (class) raised with 'opt' attribute, which is the
  15. option involved with the exception.
  16. """
  17.  
  18. # Long option support added by Lars Wirzenius <liw@iki.fi>.
  19. #
  20. # Gerrit Holl <gerrit@nl.linux.org> moved the string-based exceptions
  21. # to class-based exceptions.
  22. #
  23. # Peter ┼strand <astrand@lysator.liu.se> added gnu_getopt().
  24. #
  25. # TODO for gnu_getopt():
  26. #
  27. # - GNU getopt_long_only mechanism
  28. # - allow the caller to specify ordering
  29. # - RETURN_IN_ORDER option
  30. # - GNU extension with '-' as first character of option string
  31. # - optional arguments, specified by double colons
  32. # - a option string with a W followed by semicolon should
  33. #   treat "-W foo" as "--foo"
  34.  
  35. __all__ = ["GetoptError","error","getopt","gnu_getopt"]
  36.  
  37. import os
  38.  
  39. class GetoptError(Exception):
  40.     opt = ''
  41.     msg = ''
  42.     def __init__(self, msg, opt=''):
  43.         self.msg = msg
  44.         self.opt = opt
  45.         Exception.__init__(self, msg, opt)
  46.  
  47.     def __str__(self):
  48.         return self.msg
  49.  
  50. error = GetoptError # backward compatibility
  51.  
  52. def getopt(args, shortopts, longopts = []):
  53.     """getopt(args, options[, long_options]) -> opts, args
  54.  
  55.     Parses command line options and parameter list.  args is the
  56.     argument list to be parsed, without the leading reference to the
  57.     running program.  Typically, this means "sys.argv[1:]".  shortopts
  58.     is the string of option letters that the script wants to
  59.     recognize, with options that require an argument followed by a
  60.     colon (i.e., the same format that Unix getopt() uses).  If
  61.     specified, longopts is a list of strings with the names of the
  62.     long options which should be supported.  The leading '--'
  63.     characters should not be included in the option name.  Options
  64.     which require an argument should be followed by an equal sign
  65.     ('=').
  66.  
  67.     The return value consists of two elements: the first is a list of
  68.     (option, value) pairs; the second is the list of program arguments
  69.     left after the option list was stripped (this is a trailing slice
  70.     of the first argument).  Each option-and-value pair returned has
  71.     the option as its first element, prefixed with a hyphen (e.g.,
  72.     '-x'), and the option argument as its second element, or an empty
  73.     string if the option has no argument.  The options occur in the
  74.     list in the same order in which they were found, thus allowing
  75.     multiple occurrences.  Long and short options may be mixed.
  76.  
  77.     """
  78.  
  79.     opts = []
  80.     if type(longopts) == type(""):
  81.         longopts = [longopts]
  82.     else:
  83.         longopts = list(longopts)
  84.     while args and args[0].startswith('-') and args[0] != '-':
  85.         if args[0] == '--':
  86.             args = args[1:]
  87.             break
  88.         if args[0].startswith('--'):
  89.             opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
  90.         else:
  91.             opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
  92.  
  93.     return opts, args
  94.  
  95. def gnu_getopt(args, shortopts, longopts = []):
  96.     """getopt(args, options[, long_options]) -> opts, args
  97.  
  98.     This function works like getopt(), except that GNU style scanning
  99.     mode is used by default. This means that option and non-option
  100.     arguments may be intermixed. The getopt() function stops
  101.     processing options as soon as a non-option argument is
  102.     encountered.
  103.  
  104.     If the first character of the option string is `+', or if the
  105.     environment variable POSIXLY_CORRECT is set, then option
  106.     processing stops as soon as a non-option argument is encountered.
  107.  
  108.     """
  109.  
  110.     opts = []
  111.     prog_args = []
  112.     if isinstance(longopts, str):
  113.         longopts = [longopts]
  114.     else:
  115.         longopts = list(longopts)
  116.  
  117.     # Allow options after non-option arguments?
  118.     if shortopts.startswith('+'):
  119.         shortopts = shortopts[1:]
  120.         all_options_first = True
  121.     elif os.environ.get("POSIXLY_CORRECT"):
  122.         all_options_first = True
  123.     else:
  124.         all_options_first = False
  125.  
  126.     while args:
  127.         if args[0] == '--':
  128.             prog_args += args[1:]
  129.             break
  130.  
  131.         if args[0][:2] == '--':
  132.             opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
  133.         elif args[0][:1] == '-':
  134.             opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
  135.         else:
  136.             if all_options_first:
  137.                 prog_args += args
  138.                 break
  139.             else:
  140.                 prog_args.append(args[0])
  141.                 args = args[1:]
  142.  
  143.     return opts, prog_args
  144.  
  145. def do_longs(opts, opt, longopts, args):
  146.     try:
  147.         i = opt.index('=')
  148.     except ValueError:
  149.         optarg = None
  150.     else:
  151.         opt, optarg = opt[:i], opt[i+1:]
  152.  
  153.     has_arg, opt = long_has_args(opt, longopts)
  154.     if has_arg:
  155.         if optarg is None:
  156.             if not args:
  157.                 raise GetoptError('option --%s requires argument' % opt, opt)
  158.             optarg, args = args[0], args[1:]
  159.     elif optarg:
  160.         raise GetoptError('option --%s must not have an argument' % opt, opt)
  161.     opts.append(('--' + opt, optarg or ''))
  162.     return opts, args
  163.  
  164. # Return:
  165. #   has_arg?
  166. #   full option name
  167. def long_has_args(opt, longopts):
  168.     possibilities = [o for o in longopts if o.startswith(opt)]
  169.     if not possibilities:
  170.         raise GetoptError('option --%s not recognized' % opt, opt)
  171.     # Is there an exact match?
  172.     if opt in possibilities:
  173.         return False, opt
  174.     elif opt + '=' in possibilities:
  175.         return True, opt
  176.     # No exact match, so better be unique.
  177.     if len(possibilities) > 1:
  178.         # XXX since possibilities contains all valid continuations, might be
  179.         # nice to work them into the error msg
  180.         raise GetoptError('option --%s not a unique prefix' % opt, opt)
  181.     assert len(possibilities) == 1
  182.     unique_match = possibilities[0]
  183.     has_arg = unique_match.endswith('=')
  184.     if has_arg:
  185.         unique_match = unique_match[:-1]
  186.     return has_arg, unique_match
  187.  
  188. def do_shorts(opts, optstring, shortopts, args):
  189.     while optstring != '':
  190.         opt, optstring = optstring[0], optstring[1:]
  191.         if short_has_arg(opt, shortopts):
  192.             if optstring == '':
  193.                 if not args:
  194.                     raise GetoptError('option -%s requires argument' % opt,
  195.                                       opt)
  196.                 optstring, args = args[0], args[1:]
  197.             optarg, optstring = optstring, ''
  198.         else:
  199.             optarg = ''
  200.         opts.append(('-' + opt, optarg))
  201.     return opts, args
  202.  
  203. def short_has_arg(opt, shortopts):
  204.     for i in range(len(shortopts)):
  205.         if opt == shortopts[i] != ':':
  206.             return shortopts.startswith(':', i+1)
  207.     raise GetoptError('option -%s not recognized' % opt, opt)
  208.  
  209. if __name__ == '__main__':
  210.     import sys
  211.     print getopt(sys.argv[1:], "a:b", ["alpha=", "beta"])
  212.